home *** CD-ROM | disk | FTP | other *** search
/ PC World 2000 February / PCWorld_2000-02_cd.bin / Software / Servis / FFE / EXEC.SWG / 0013_Windows Executables.pas < prev   
Pascal/Delphi Source File  |  1997-05-11  |  20KB  |  435 lines
  1. .EXE Executable-File Header Format (3.1)
  2.  
  3. An  executable  (.EXE) file for  the  Microsoft Windows operating system
  4. contains  a combination of code and data or a combination of code, data,
  5. and  resources. The executable file also contains two headers: an MS-DOS
  6. header  and  a  Windows  header. The  next  two  sections describe these
  7. headers;  the  third section describes the  code and data contained in a
  8. Windows executable file.
  9.  
  10. MS-DOS Header
  11.  
  12. The  MS-DOS  (old-style) executable-file  header  contains four distinct
  13. parts:  a collection of header information  (such as the signature word,
  14. the  file  size, and so on), a  reserved section, a pointer to a Windows
  15. header  (if one exists), and a  stub program. The following illustration
  16. shows the MS-DOS executable-file header: If the word value at offset 18h
  17. is  40h  or greater, the word value at  3Ch  is typically an offset to a
  18. Windows  header. Applications must verify  this for each executable-file
  19. header  being tested, because a few applications have a different header
  20. style.  MS-DOS uses the stub program to display a message if Windows has
  21. not  been  loaded  when  the user attempts  to  run  a program. For more
  22. information  about the MS-DOS executable-file  header, see the Microsoft
  23. MS-DOS  Programmer's  Reference (Redmond,  Washington:  Microsoft Press,
  24. 1991).
  25.  
  26. Windows Header
  27.  
  28. The Windows (new-style) executable-file header contains information that
  29. the  loader  requires for segmented  executable  files. This information
  30. includes  the linker version number, data  specified by the linker, data
  31. specified  by  the resource compiler, tables  of segment data, tables of
  32. resource  data, and so on. The  following illustration shows the Windows
  33. executable-file  header: The following sections  describe the entries in
  34. the Windows executable-file header.
  35.  
  36. Information Block
  37.  
  38. The  information block in the Windows header contains the linker version
  39. number,  the  lengths  of  various  tables  that  further  describe  the
  40. executable  file,  the offsets from the  beginning  of the header to the
  41. beginning  of  these  tables, the heap and  stack  sizes, and so on. The
  42. following  list summarizes the contents  of the header information block
  43. (the locations are relative to the beginning of the block):
  44.  
  45. Location    Description
  46.  
  47. 00h    Specifies the signature word. The low byte contains "N" (4Eh) and the high byte contains "E" (45h).
  48. 02h    Specifies the linker version number.
  49. 03h    Specifies the linker revision number.
  50. 04h    Specifies the offset to the entry table (relative to the beginning of the header).
  51. 06h    Specifies the length of the entry table, in bytes.
  52. 08h    Reserved.
  53. 0Ch    Specifies flags that describe the contents of the executable file. This value can be one or more of the following bits:
  54.  
  55. Bit    Meaning
  56.  
  57. 0    The linker sets this bit if the executable-file format is SINGLEDATA. An executable file with this format
  58. contains one data segment. This bit is set if the file is a dynamic-link library (DLL).
  59. 1    The linker sets this bit if the executable-file format is MULTIPLEDATA. An executable file with this format
  60. contains multiple data segments. This bit is set if the file is a Windows application.
  61.  
  62. If  neither  bit  0  nor bit 1  is  set,  the  executable-file format is
  63. NOAUTODATA.  An  executable  file with this  format  does not contain an
  64. automatic data segment.
  65.  
  66. 2    Reserved.
  67. 3    Reserved.
  68. 8    Reserved.
  69. 9    Reserved.
  70. 11    If this bit is set, the first segment in the executable file contains code that loads the application.
  71. 13    If this bit is set, the linker detects errors at link time but still creates an executable file.
  72. 14    Reserved.
  73. 15    If this bit is set, the executable file is a library module.
  74.  
  75. If  bit  15  is  set, the  CS:IP  registers  point  to an initialization
  76. procedure  called with the value in the  AX register equal to the module
  77. handle.  The  initialization procedure must execute  a far return to the
  78. caller.  If  the  procedure is successful,  the  value in AX is nonzero.
  79. Otherwise,  the value in AX is zero. The value in the DS register is set
  80. to the library's data segment if SINGLEDATA is set. Otherwise, DS is set
  81. to the data segment of the application that loads the library.
  82.  
  83. 0Eh    Specifies the automatic data segment number. (0Eh is zero if the SINGLEDATA and MULTIPLEDATA bits are
  84. cleared.)
  85. 10h    Specifies the initial size, in bytes, of the local heap. This value is zero if there is no local allocation.
  86. 12h    Specifies the initial size, in bytes, of the stack. This value is zero if the SS register value does not equal the DS
  87. register value.
  88. 14h    Specifies the segment:offset value of CS:IP.
  89. 18h    Specifies the segment:offset value of SS:SP.
  90.  
  91. The value specified in SS is an index to the module's segment table. The
  92. first  entry in the segment table corresponds to segment number 1. If SS
  93. addresses  the  automatic data segment and SP  is zero, SP is set to the
  94. address obtained by adding the size of the automatic data segment to the
  95. size of the stack.
  96.  
  97. 1Ch    Specifies the number of entries in the segment table.
  98. 1Eh    Specifies the number of entries in the module-reference table.
  99. 20h    Specifies the number of bytes in the nonresident-name table.
  100. 22h    Specifies a relative offset from the beginning of the Windows header to the beginning of the segment table.
  101. 24h    Specifies a relative offset from the beginning of the Windows header to the beginning of the resource table.
  102. 26h    Specifies a relative offset from the beginning of the Windows header to the beginning of the resident-name table.
  103. 28h    Specifies a relative offset from the beginning of the Windows header to the beginning of the module-reference table.
  104. 2Ah    Specifies a relative offset from the beginning of the Windows header to the beginning of the imported-name table.
  105. 2Ch    Specifies a relative offset from the beginning of the file to the beginning of the nonresident-name table.
  106.  
  107. 30h    Specifies the number of movable entry points.
  108. 32h    Specifies a shift count that is used to align the logical sector. This count is log2 of the segment sector size. It is
  109. typically 4, although the default count is 9. (This value corresponds to the /alignment [/a] linker switch. When the
  110. linker command line contains /a:16, the shift count is 4. When the linker command line contains /a:512, the shift
  111. count is 9.)
  112. 34h    Specifies the number of resource segments.
  113. 36h    Specifies the target operating system, depending on which bits are set:
  114.  
  115. Bit    Meaning
  116.  
  117. 0    Operating system format is unknown.
  118. 1    Reserved.
  119. 2    Operating system is Microsoft Windows.
  120. 3    Reserved.
  121. 4    Reserved.
  122.  
  123. 37h    Specifies additional information about the executable file. It can be one or more of the following values:
  124.  
  125. Bit    Meaning
  126.  
  127. 1    If this bit is set, the executable file contains a Windows 2.x application that runs in version 3.x protected
  128. mode.
  129. 2    If this bit is set, the executable file contains a Windows 2.x application that supports proportional fonts.
  130. 3    If this bit is set, the executable file contains a fast-load area.
  131.  
  132. 38h    Specifies the offset, in sectors, to the beginning of the fast-load area. (Only Windows uses this value.)
  133. 3Ah    Specifies the length, in sectors, of the fast-load area. (Only Windows uses this value.)
  134. 3Ch    Reserved.
  135. 3Eh    Specifies the expected version number for Windows. (Only Windows uses this value.)
  136.  
  137. Segment Table
  138.  
  139. The segment table contains information that describes each segment in an executable file. This information includes the
  140. segment length, segment type, and segment-relocation data. The following list summarizes the values found in the segment
  141. table (the locations are relative to the beginning of each entry):
  142.  
  143. Location    Description
  144.  
  145. 00h    Specifies the offset, in sectors, to the segment data (relative to the beginning of the file). A value of zero means no
  146. data exists.
  147. 02h    Specifies the length, in bytes, of the segment, in the file. A value of zero indicates that the segment length is 64K,
  148. unless the selector offset is also zero.
  149. 04h    Specifies flags that describe the contents of the executable file. This value can be one or more of the following:
  150.  
  151. Bit    Meaning
  152.  
  153. 0    If this bit is set, the segment is a data segment. Otherwise, the segment is a code segment.
  154. 1    If this bit is set, the loader has allocated memory for the segment.
  155. 2    If this bit is set, the segment is loaded.
  156. 3    Reserved.
  157. 4    If this bit is set, the segment type is MOVABLE. Otherwise, the segment type is FIXED.
  158. 5    If this bit is set, the segment type is PURE or SHAREABLE. Otherwise, the segment type is IMPURE or
  159. NONSHAREABLE.
  160. 6    If this bit is set, the segment type is PRELOAD. Otherwise, the segment type is LOADONCALL.
  161. 7    If this bit is set and the segment is a code segment, the segment type is EXECUTEONLY. If this bit is set
  162. and the segment is a data segment, the segment type is READONLY.
  163.  
  164. 8    If this bit is set, the segment contains relocation data.
  165. 9    Reserved.
  166. 10    Reserved.
  167. 11    Reserved.
  168. 12    If this bit is set, the segment is discardable.
  169. 13    Reserved.
  170. 14    Reserved.
  171. 15    Reserved.
  172.  
  173. 06h    Specifies the minimum allocation size of the segment, in bytes. A value of zero indicates that the minimum allocation
  174. size is 64K.
  175.  
  176. Resource Table
  177.  
  178. The  resource  table  describes  and  identifies  the  location  of each
  179. resource in the executable file. The table has the following form:
  180.  
  181.  
  182.  
  183. WORD     rscAlignShift;
  184. TYPEINFO rscTypes[];
  185. WORD     rscEndTypes;
  186. BYTE     rscResourceNames[];
  187. BYTE     rscEndNames;
  188.  
  189. Following are the members in the resource table:
  190.  
  191. rscAlignShift    Specifies the alignment shift count for resource data. When the shift count is used as an exponent of 2,
  192. the resulting value specifies the factor, in bytes, for computing the location of a resource in the
  193. executable file.
  194. rscTypes    Specifies an array of TYPEINFO structures containing information about resource types. There must
  195. be one TYPEINFO structure for each type of resource in the executable file.
  196. rscEndTypes    Specifies the end of the resource type definitions. This member must be zero.
  197. rscResourceNames    Specifies the names (if any) associated with the resources in this table. Each name is stored as
  198. consecutive bytes; the first byte specifies the number of characters in the name.
  199. rscEndNames    Specifies the end of the resource names and the end of the resource table. This member must be
  200. zero.
  201.  
  202. Type Information
  203.  
  204. The TYPEINFO structure has the following form:
  205.  
  206.  
  207.  
  208. typedef struct _TYPEINFO {
  209.     WORD        rtTypeID;
  210.     WORD        rtResourceCount;
  211.     DWORD       rtReserved;
  212.     NAMEINFO    rtNameInfo[];
  213. } TYPEINFO;
  214.  
  215. Following are the members in the TYPEINFO structure:
  216.  
  217. rtTypeID    Specifies the type identifier of the resource. This integer value is either a resource-type value or an offset
  218. to a resource-type name. If the high bit in this member is set (0x8000), the value is one of the following
  219. resource-type values:
  220.  
  221. Value    Resource type
  222.  
  223. RT_ACCELERATOR    Accelerator table
  224. RT_BITMAP    Bitmap
  225. RT_CURSOR    Cursor
  226. RT_DIALOG    Dialog box
  227. RT_FONT    Font component
  228. RT_FONTDIR    Font directory
  229. RT_GROUP_CURSOR    Cursor directory
  230. RT_GROUP_ICON    Icon directory
  231. RT_ICON    Icon
  232. RT_MENU    Menu
  233. RT_RCDATA    Resource data
  234. RT_STRING    String table
  235.  
  236. If  the  high  bit  of the value in  this  member  is not set, the value
  237. represents an offset, in bytes relative to the beginning of the resource
  238. table, to a name in the rscResourceNames member.
  239.  
  240. rtResourceCount    Specifies the number of resources of this type in the executable file.
  241. rtReserved    Reserved.
  242. rtNameInfo    Specifies an array of NAMEINFO structures containing information about individual resources. The
  243. rtResourceCount member specifies the number of structures in the array.
  244.  
  245. Name Information
  246.  
  247. The NAMEINFO structure has the following form:
  248.  
  249.  
  250.  
  251. typedef struct _NAMEINFO {
  252.     WORD rnOffset;
  253.     WORD rnLength;
  254.     WORD rnFlags;
  255.     WORD rnID;
  256.     WORD rnHandle;
  257.     WORD rnUsage;
  258. } NAMEINFO;
  259.  
  260. Following are the members in the NAMEINFO structure:
  261.  
  262. rnOffset    Specifies an offset to the contents of the resource data (relative to the beginning of the file). The offset is in terms of
  263. alignment units specified by the rscAlignShift member at the beginning of the resource table.
  264. rnLength    Specifies the resource length, in bytes.
  265. rnFlags    Specifies whether the resource is fixed, preloaded, or shareable. This member can be one or more of the following
  266. values:
  267.  
  268. Value    Meaning
  269.  
  270. 0x0010    Resource is movable (MOVEABLE). Otherwise, it is fixed.
  271. 0x0020    Resource can be shared (PURE).
  272. 0x0040    Resource is preloaded (PRELOAD). Otherwise, it is loaded on demand.
  273.  
  274. rnID    Specifies or points to the resource identifier. If the identifier is an integer, the high bit is set (8000h). Otherwise, it is an
  275. offset to a resource string, relative to the beginning of the resource table.
  276. rnHandle    Reserved.
  277. rnUsage    Reserved.
  278.  
  279. Resident-Name Table
  280.  
  281. The   resident-name  table  contains   strings  that  identify  exported
  282. functions in the executable file. As the name implies, these strings are
  283. resident  in  system memory and  are  never discarded. The resident-name
  284. strings  are  case-sensitive and are  not null-terminated. The following
  285. list  summarizes  the  values  found  in  the  resident-name  table (the
  286. locations are relative to the beginning of each entry):
  287.  
  288. Location    Description
  289.  
  290. 00h    Specifies the length of a string. If there are no more strings in the table, this value is zero.
  291. 01h - xxh    Specifies the resident-name text. This string is case-sensitive and is not null-terminated.
  292. xxh + 01h    Specifies an ordinal number that identifies the string. This number is an index into the entry table.
  293.  
  294. The first string in the resident-name table is the module name.
  295.  
  296. Module-Reference Table
  297.  
  298. The module-reference table contains offsets for module names stored in the imported-name table. Each entry in this table is 2
  299. bytes long.
  300.  
  301. Imported-Name Table
  302.  
  303. The   imported-name  table  contains  the  names  of  modules  that  the
  304. executable  file  imports. Each entry contains  two parts: a single byte
  305. that  specifies  the  length of the  string  and  the string itself. The
  306. strings in this table are not null-terminated.
  307.  
  308. Entry Table
  309.  
  310. The  entry  table contains bundles of  entry  points from the executable
  311. file  (the linker generates each bundle). The numbering system for these
  312. ordinal  values is 1-based--that is,  the ordinal value corresponding to
  313. the  first  entry point is 1.  The linker generates the densest possible
  314. bundles  under the restriction that it  cannot reorder the entry points.
  315. This  restriction is necessary because  other executable files may refer
  316. to  entry  points  within a given  bundle  by  their ordinal values. The
  317. entry-table  data  is organized by bundle,  each  of which begins with a
  318. 2-byte  header.  The  first byte of  the  header specifies the number of
  319. entries  in the bundle (a value of 00h designates the end of the table).
  320. The  second byte specifies whether  the corresponding segment is movable
  321. or  fixed. If the value in this byte is 0FFh, the segment is movable. If
  322. the  value  in this byte is 0FEh, the  entry does not refer to a segment
  323. but  refers,  instead, to a constant  defined  within the module. If the
  324. value in this byte is neither 0FFh nor 0FEh, it is a segment index.
  325.  
  326. For movable segments, each entry consists of 6 bytes and has the following form:
  327.  
  328. Location    Description
  329.  
  330. 00h    Specifies a byte value. This value can be a combination of the following bits:
  331.  
  332. Bit(s)    Meaning
  333.  
  334. 0    If this bit is set, the entry is exported.
  335. 1    If this bit is set, the segment uses a global (shared) data segment.
  336. 3-7    If the executable file contains code that performs ring transitions, these bits specify the number of words
  337. that compose the stack. At the time of the ring transition, these words must be copied from one ring to the
  338. other.
  339.  
  340. 01h    Specifies an int 3fh instruction.
  341. 03h    Specifies the segment number.
  342. 04h    Specifies the segment offset.
  343.  
  344. For fixed segments, each entry consists of 3 bytes and has the following form:
  345.  
  346. Location    Description
  347.  
  348. 00h    Specifies a byte value. This value can be a combination of the following bits:
  349.  
  350. Bit(s)    Meaning
  351.  
  352. 0    If this bit is set, the entry is exported.
  353. 1    If this bit is set, the entry uses a global (shared) data segment. (This may be set only for SINGLEDATA
  354. library modules.)
  355. 3-7    If the executable file contains code that performs ring transitions, these bits specify the number of words
  356. that compose the stack. At the time of the ring transition, these words must be copied from one ring to the
  357. other.
  358.  
  359. 01h    Specifies an offset.
  360.  
  361. Nonresident-Name Table
  362.  
  363. The  nonresident-name  table  contains  strings  that  identify exported
  364. functions in the executable file. As the name implies, these strings are
  365. not   always  resident  in  system   memory  and  are  discardable.  The
  366. nonresident-name    strings    are   case-sensitive;    they   are   not
  367. null-terminated.  The following list summarizes  the values found in the
  368. nonresident-name  table  (the  specified locations  are  relative to the
  369. beginning of each entry):
  370.  
  371. Location    Description
  372.  
  373. 00h    Specifies the length, in bytes, of a string. If this byte is 00h, there are no more strings in the table.
  374. 01h - xxh    Specifies the nonresident-name text. This string is case-sensitive and is not null-terminated.
  375. xx + 01h    Specifies an ordinal number that is an index to the entry table.
  376.  
  377. The first name that appears in the nonresident-name table is the module description string (which was specified in the
  378. module-definition file).
  379.  
  380. Code Segments and Relocation Data
  381.  
  382. Code  and  data  segments follow the  Windows  header.  Some of the code
  383. segments  may  contain  calls to functions  in  other  segments and may,
  384. therefore,  require  relocation data to  resolve  those references. This
  385. relocation data is stored in a relocation table that appears immediately
  386. after  the code or data in the segment.  The first 2 bytes in this table
  387. specify  the number of relocation items the table contains. A relocation
  388. item is a collection of bytes specifying the following information:
  389.  
  390.     Address type (segment only, offset only, segment and offset)
  391.  
  392.     Relocation type (internal reference, imported ordinal, imported name)
  393.  
  394.     Segment number or ordinal identifier (for internal references)
  395.  
  396.     Reference-table index or function ordinal number (for imported ordinals)
  397.  
  398.     Reference-table index or name-table offset (for imported names)
  399.  
  400. Each relocation item contains 8 bytes of data, the first byte of which specifies one of the following relocation-address types:
  401.  
  402. Value    Meaning
  403.  
  404. 0    Low byte at the specified offset
  405. 2    16-bit selector
  406. 3    32-bit pointer
  407. 5    16-bit offset
  408. 11    48-bit pointer
  409. 13    32-bit offset
  410.  
  411. The second byte specifies one of the following relocation types:
  412.  
  413. Value    Meaning
  414.  
  415. 0    Internal reference
  416. 1    Imported ordinal
  417. 2    Imported name
  418. 3       OSFIXUP
  419.  
  420. The  third  and fourth bytes specify  the  offset of the relocation item
  421. within  the  segment.  If the relocation  type  is imported ordinal, the
  422. fifth and sixth bytes specify an index to a module's reference table and
  423. the  seventh  and eighth bytes specify  a function ordinal value. If the
  424. relocation  type is imported name, the  fifth and sixth bytes specify an
  425. index  to  a module's reference table  and  the seventh and eighth bytes
  426. specify  an offset to an imported-name  table. If the relocation type is
  427. internal  reference  and the segment is  fixed, the fifth byte specifies
  428. the  segment number, the sixth byte is  zero, and the seventh and eighth
  429. bytes  specify  an  offset  to the  segment.  If  the relocation type is
  430. internal  reference and the segment is movable, the fifth byte specifies
  431. 0FFh,  the sixth byte is zero; and  the seventh and eighth bytes specify
  432. an ordinal value found in the segment's entry table.
  433.  
  434.  
  435.